package main

import (
	"context"
	"fmt"
	"log"
	"math"
	"math/rand"
	"net"
	"sync"
	"time"
)

// ModbusServer TCP服务器结构
type ModbusServer struct {
	listener net.Listener
	ctx      context.Context
	cancel   context.CancelFunc
	wg       sync.WaitGroup
	handler  *CustomServerHandler
}

// GatewaySimulator 网关协议模拟器
type GatewaySimulator struct {
	// 数据存储
	dataRecords   map[int][]byte         // 数据记录存储
	currentData   map[int][]byte         // 当前数据存储
	subDevParams  map[int]map[int][]byte // 子设备参数存储
	gatewayParams map[int][]byte         // 网关参数存储

	// 线程安全锁
	mu sync.RWMutex

	// 数据模拟器
	simulator *DataSimulator
}

// DataSimulator 数据模拟器
type DataSimulator struct {
	startTime time.Time
	amplitude float64
	frequency float64
	noise     float64
}

// NewDataSimulator 创建数据模拟器
func NewDataSimulator() *DataSimulator {
	return &DataSimulator{
		startTime: time.Now(),
		amplitude: 50.0, // 50%的振幅
		frequency: 0.1,  // 0.1Hz频率
		noise:     5.0,  // 5%的噪声
	}
}

// GenerateValue 生成模拟数据值
func (ds *DataSimulator) GenerateValue(unitID int, offset float64) float64 {
	elapsed := time.Since(ds.startTime).Seconds()

	// 基于unitID生成不同的基础值
	baseValue := float64(unitID * 10)

	// 正弦波 + 随机噪声
	sinValue := math.Sin(2*math.Pi*ds.frequency*elapsed+offset) * ds.amplitude
	noiseValue := (rand.Float64() - 0.5) * ds.noise

	return baseValue + sinValue + noiseValue
}

// NewGatewaySimulator 创建网关模拟器
func NewGatewaySimulator() *GatewaySimulator {
	simulator := &GatewaySimulator{
		dataRecords:   make(map[int][]byte),
		currentData:   make(map[int][]byte),
		subDevParams:  make(map[int]map[int][]byte),
		gatewayParams: make(map[int][]byte),
		simulator:     NewDataSimulator(),
	}

	// 初始化模拟数据
	simulator.initializeSimulatedData()

	// 启动数据更新goroutine
	go simulator.updateDataPeriodically()

	return simulator
}

// initializeSimulatedData 初始化模拟数据
func (gs *GatewaySimulator) initializeSimulatedData() {
	// 初始化变送器数据（Unit ID 1-64）
	for unitID := 1; unitID <= 64; unitID++ {
		// 初始化数据记录（100条记录）
		for recordIndex := 0; recordIndex < 100; recordIndex++ {
			key := unitID*1000 + recordIndex
			gs.dataRecords[key] = gs.generateDataRecord(unitID, float64(recordIndex))
		}

		// 初始化当前数据
		gs.currentData[unitID] = gs.generateCurrentData(unitID)

		// 初始化子设备参数
		gs.subDevParams[unitID] = make(map[int][]byte)
		for addr := 0; addr < 50; addr++ {
			gs.subDevParams[unitID][addr] = gs.generateSubDevParam(unitID, addr)
		}
	}

	// 初始化网关参数（Unit ID 65-247）
	for unitID := 65; unitID <= 247; unitID++ {
		gs.gatewayParams[unitID] = make([]byte, 4)
		// 生成随机的网关参数
		for i := 0; i < 4; i++ {
			gs.gatewayParams[unitID][i] = byte(rand.Intn(256))
		}
	}
}

// generateDataRecord 生成16字节数据记录
// 数据格式：压力(4) + 压力单位(1) + 电池电量(1) + 连接状态(1) + 信号(1) + 时间戳(4) + 保留(4)
// 示例：41 C8 00 00 05 50 01 04 00 00 00 00 68 E8 A1 20
func (gs *GatewaySimulator) generateDataRecord(unitID int, offset float64) []byte {
	record := make([]byte, 16)

	// 字段1-4：压力值 (IEEE 754, 大端)
	pressure := gs.simulator.GenerateValue(unitID, offset)
	pressureBytes := Float32ToBytes(float32(pressure))
	copy(record[0:4], pressureBytes)

	// 字艖5：压力单位 (0=Pa, 1=kPa, 2=MPa, 3=bar, 4=psi, 5=kPa)
	record[4] = 0x05 // kPa

	// 字艖6：电池电量 (0-100%)
	batteryLevel := 50 + rand.Intn(50) // 50-100%
	record[5] = byte(batteryLevel)

	// 字艖7：连接状态 (0=断开, 1=连接正常, 2=连接异常)
	record[6] = 0x01 // 连接正常

	// 字艖8：信号强度 (0-5格)
	signalLevel := 3 + rand.Intn(3) // 3-5格信号
	record[7] = byte(signalLevel)

	// 字节8-11：保留字段 (用于未来扩展)
	record[8] = 0x00
	record[9] = 0x00
	record[10] = 0x00
	record[11] = 0x00

	// 字节12-15：数据采集时间 (Unix timestamp, 大端)
	timestamp := uint32(time.Now().Unix() - int64(offset*60)) // 每条记录间隔1分钟
	timestampBytes := Uint32ToBytes(timestamp)
	copy(record[12:16], timestampBytes)

	return record
}

// generateDataRecordWithTimestamp 生成带指定时间戳的16字节数据记录
// 数据格式：压力(4) + 压力单位(1) + 电池电量(1) + 连接状态(1) + 信号(1) + 时间戳(4) + 保留(4)
func (gs *GatewaySimulator) generateDataRecordWithTimestamp(unitID int, timestamp uint32, offset float64) []byte {
	record := make([]byte, 16)

	// 字段1-4：压力值 (IEEE 754, 大端)
	pressure := gs.simulator.GenerateValue(unitID, offset)
	pressureBytes := Float32ToBytes(float32(pressure))
	copy(record[0:4], pressureBytes)

	// 字艖5：压力单位 (0=Pa, 1=kPa, 2=MPa, 3=bar, 4=psi, 5=kPa)
	record[4] = 0x05 // kPa

	// 字艖6：电池电量 (0-100%)
	batteryLevel := 50 + rand.Intn(50) // 50-100%
	record[5] = byte(batteryLevel)

	// 字艖7：连接状态 (0=断开, 1=连接正常, 2=连接异常)
	record[6] = 0x01 // 连接正常

	// 字艖8：信号强度 (0-5格)
	signalLevel := 3 + rand.Intn(3) // 3-5格信号
	record[7] = byte(signalLevel)

	// 字节8-11：保留字段 (用于未来扩展)
	record[8] = 0x00
	record[9] = 0x00
	record[10] = 0x00
	record[11] = 0x00

	// 字节12-15：使用指定的时间戳 (Unix timestamp, 大端)
	timestampBytes := Uint32ToBytes(timestamp)
	copy(record[12:16], timestampBytes)

	return record
}

// generateCurrentData 生成当前16字节数据
func (gs *GatewaySimulator) generateCurrentData(unitID int) []byte {
	return gs.generateDataRecord(unitID, 0)
}

// generateSubDevParam 生成子设备参数
func (gs *GatewaySimulator) generateSubDevParam(unitID int, addr int) []byte {
	// 根据地址生成不同长度的参数
	switch addr % 4 {
	case 0: // 4字节参数
		return Uint32ToBytes(uint32(unitID*100 + addr))
	case 1: // 2字节参数
		return Uint16ToBytes(uint16(unitID*10 + addr))
	case 2: // 1字节参数
		return []byte{byte(unitID + addr)}
	default: // IEEE 754浮点数
		value := float32(unitID+addr) * 1.5
		return Float32ToBytes(value)
	}
}

// updateDataPeriodically 定期更新数据
func (gs *GatewaySimulator) updateDataPeriodically() {
	ticker := time.NewTicker(2 * time.Second) // 每2秒更新一次
	defer ticker.Stop()

	for range ticker.C {
		gs.mu.Lock()
		// 更新所有变送器的当前数据
		for unitID := 1; unitID <= 64; unitID++ {
			gs.currentData[unitID] = gs.generateCurrentData(unitID)
		}
		gs.mu.Unlock()
	}
}

// 功能码处理函数

// HandleFunction0x50 处理读数据记录
// 协议规范：
// 1. 数据对齐模式（count=1）：请求7字节，响应功能码+记录数(0x0001)+单记录字节数(0x04)+4字节时间戳
// 2. 数据读取模式（count=32）：请求7字节，响应功能码+记录数(0x0020)+单记录字节数(0x10)+512字节数据
func (gs *GatewaySimulator) HandleFunction0x50(unitID uint8, data []byte) ([]byte, error) {
	if len(data) < 6 {
		return nil, fmt.Errorf("invalid data length for function 0x50: expected 6, got %d", len(data))
	}

	// 解析请求：时间戳(4字节) + 记录条数(2字节)
	timestamp := uint32(data[0])<<24 | uint32(data[1])<<16 | uint32(data[2])<<8 | uint32(data[3])
	count := uint16(data[4])<<8 | uint16(data[5])

	fmt.Printf("📊 功能码0x50 - Unit ID: %d, 时间戳: %d, 记录条数: %d\n", unitID, timestamp, count)

	gs.mu.RLock()
	defer gs.mu.RUnlock()

	// 判断是数据对齐还是数据读取
	if count == 1 {
		// 3.1.1.1 数据对齐模式
		// 响应：记录数(2) + 单记录字节数(1) + 4字节时间戳
		fmt.Println("🔄 数据对齐模式：返回对齐时间戳")

		// 计算对齐的时间戳（向前对齐到2分钟的倍数）
		currentTime := uint32(time.Now().Unix())
		alignedTimestamp := (currentTime / 120) * 120 // 对齐到2分钟边界

		response := make([]byte, 7) // 记录数(2) + 单记录字节数(1) + 时间戳(4)
		response[0] = 0x00          // 记录数高字节
		response[1] = 0x01          // 记录数低字节：1条
		response[2] = 0x04          // 单记录字节数：4字节

		// 4字节时间戳（大端）
		response[3] = byte(alignedTimestamp >> 24)
		response[4] = byte(alignedTimestamp >> 16)
		response[5] = byte(alignedTimestamp >> 8)
		response[6] = byte(alignedTimestamp)

		fmt.Printf("✅ 返回对齐时间戳: %d (%s)\n", alignedTimestamp, time.Unix(int64(alignedTimestamp), 0).Format("2006-01-02 15:04:05"))
		return response, nil

	} else if count == 32 {
		// 3.1.1.2 数据读取模式
		// 响应：记录数(2) + 单记录字节数(1) + 512字节数据（32条×16字节）
		fmt.Println("📚 数据读取模式：返回32条历史数据记录")

		response := make([]byte, 3+512) // 记录数(2) + 单记录字节数(1) + 512字节数据
		response[0] = 0x00              // 记录数高字节
		response[1] = 0x20              // 记录数低字节：32条
		response[2] = 0x10              // 单记录字节数：16字节

		// 生成32条历史数据记录，每个数据点按照请求时间戳+秒数
		for i := 0; i < 32; i++ {
			// 计算当前数据点的时间戳：请求时间戳 + i 秒
			dataTimestamp := timestamp + uint32(i)

			// 生成数据记录，使用指定的时间戳
			record := gs.generateDataRecordWithTimestamp(int(unitID), dataTimestamp, float64(i))
			copy(response[3+i*16:3+(i+1)*16], record)
		}

		fmt.Printf("✅ 返回32条历史数据记录（时间戳范围: %d - %d）\n", timestamp, timestamp+31)
		return response, nil

	} else {
		return nil, fmt.Errorf("unsupported record count for function 0x50: %d (expected 1 or 32)", count)
	}
}

// HandleFunction0x51 处理读当前数据
// 响应格式：功能码(1) + 记录数(1) + 单记录字节数(1) + 16字节数据
// 总PDU长度：1 + 1 + 1 + 16 = 19 字节
func (gs *GatewaySimulator) HandleFunction0x51(unitID uint8, data []byte) ([]byte, error) {
	gs.mu.RLock()
	defer gs.mu.RUnlock()

	// 生成或获取当前数据
	var currentData []byte
	if existingData, exists := gs.currentData[int(unitID)]; exists {
		currentData = existingData
	} else {
		currentData = gs.generateCurrentData(int(unitID)) // 类型转换
	}
	//打印去读的数据
	/*
		字节  0-3 : 压力值 (IEEE 754大端浮点数)
		字节    4 : 压力单位 (0x05 = kPa)
		字节    5 : 电池电量 (50-100%)
		字节    6 : 连接状态 (0x01 = 正常)
		字节    7 : 信号强度 (3-5格)
		字节  8-11: 保留字段 (0x00000000)
		字节 12-15: 采集时间 (Unix时间戳大端)
	*/
	// 使用转换函数美化输出
	fmt.Printf("压力值: %.2f %s\n",
		BytesToFloat32(currentData[0:4]),
		GetPressureUnitName(currentData[4]))
	fmt.Printf("电池电量: %d%%\n", currentData[5])
	fmt.Printf("连接状态: %s (0x%02X)\n",
		GetConnectionStatusName(currentData[6]), currentData[6])
	fmt.Printf("信号强度: %d格\n", currentData[7])
	fmt.Printf("保留字段: %02X %02X %02X %02X\n",
		currentData[8], currentData[9], currentData[10], currentData[11])
	fmt.Printf("采集时间: %s (Unix: %d)\n",
		FormatTimestamp(BytesToUint32(currentData[12:16])),
		BytesToUint32(currentData[12:16]))
	// 构建响应：记录数(1) + 单记录字节数(1) + 16字节数据
	response := make([]byte, 3+16) // 不包含功能码
	response[0] = 0x00             // 记录数：1条
	response[1] = 0x01             // 记录数：1条
	response[2] = 0x10             // 单记录字节数：16字节
	copy(response[3:], currentData)

	return response, nil
}

// HandleFunction0x52 处理写子设备参数
// 协议规范：请求7字节（地址2字节+参数值4字节），响应7字节（地址2字节+参数值4字节）
func (gs *GatewaySimulator) HandleFunction0x52(unitID uint8, data []byte) ([]byte, error) {
	// 验证数据长度：地址(2字节) + 参数值(4字节) = 6字节
	if len(data) < 6 {
		return nil, fmt.Errorf("invalid data length for function 0x52: expected 6, got %d", len(data))
	}

	// 验证Unit ID范围（子设备：1-64）
	if unitID < 1 || unitID > 64 {
		return nil, fmt.Errorf("invalid unit ID for sub-device: %d (expected 1-64)", unitID)
	}

	addr := uint16(data[0])<<8 | uint16(data[1])
	paramValue := uint32(data[2])<<24 | uint32(data[3])<<16 | uint32(data[4])<<8 | uint32(data[5])

	// 验证参数地址范围（子设备参数：0x0001-0x000A）
	if addr < 0x0001 || addr > 0x000A {
		return nil, fmt.Errorf("invalid parameter address for sub-device: 0x%04X (expected 0x0001-0x000A)", addr)
	}

	// 验证参数值合法性（根据地址类型）
	if err := gs.validateSubDeviceParam(addr, paramValue); err != nil {
		return nil, fmt.Errorf("invalid parameter value: %v", err)
	}

	fmt.Printf("🔧 功能码0x52 - Unit ID: %d, 地址: 0x%04X, 参数值: 0x%08X (%d)\n",
		unitID, addr, paramValue, paramValue)

	gs.mu.Lock()
	defer gs.mu.Unlock()

	if gs.subDevParams[int(unitID)] == nil {
		gs.subDevParams[int(unitID)] = make(map[int][]byte)
	}

	// 存储参数（4字节大端格式）
	paramBytes := Uint32ToBytes(paramValue)
	gs.subDevParams[int(unitID)][int(addr)] = make([]byte, 4)
	copy(gs.subDevParams[int(unitID)][int(addr)], paramBytes)

	// 返回确认：地址(2字节) + 参数值(4字节)
	response := make([]byte, 6)
	response[0] = data[0] // 地址高字节
	response[1] = data[1] // 地址低字节
	response[2] = data[2] // 参数值字节0
	response[3] = data[3] // 参数值字节1
	response[4] = data[4] // 参数值字节2
	response[5] = data[5] // 参数值字节3

	fmt.Printf("✅ 子设备参数写入成功\n")
	return response, nil
}

// HandleFunction0x53 处理写网关参数
// 协议规范：请求7字节（地址2字节+参数值4字节），响应7字节（地址2字节+参数值4字节）
func (gs *GatewaySimulator) HandleFunction0x53(unitID uint8, data []byte) ([]byte, error) {
	// 验证数据长度：地址(2字节) + 参数值(4字节) = 6字节
	if len(data) < 6 {
		return nil, fmt.Errorf("invalid data length for function 0x53: expected 6, got %d", len(data))
	}

	// 验证Unit ID范围（网关：65-247）
	if unitID < 1 || unitID > 247 {
		return nil, fmt.Errorf("invalid unit ID for gateway: %d (expected 65-247)", unitID)
	}

	addr := uint16(data[0])<<8 | uint16(data[1])
	paramValue := uint32(data[2])<<24 | uint32(data[3])<<16 | uint32(data[4])<<8 | uint32(data[5])

	// 验证参数地址范围（网关参数：0x0001-0x0004）
	if addr < 0x0001 || addr > 0x0004 {
		return nil, fmt.Errorf("invalid parameter address for gateway: 0x%04X (expected 0x0001-0x0004)", addr)
	}

	// 验证参数值合法性（根据地址类型）
	if err := gs.validateGatewayParam(addr, paramValue); err != nil {
		return nil, fmt.Errorf("invalid parameter value: %v", err)
	}

	fmt.Printf("🔧 功能码0x53 - Unit ID: %d, 地址: 0x%04X, 参数值: 0x%08X (%d)\n",
		unitID, addr, paramValue, paramValue)

	gs.mu.Lock()
	defer gs.mu.Unlock()

	// 存储网关参数（4字节大端格式）
	paramBytes := Uint32ToBytes(paramValue)
	gs.gatewayParams[int(unitID)] = make([]byte, 4)
	copy(gs.gatewayParams[int(unitID)], paramBytes)

	// 返回确认：地址(2字节) + 参数值(4字节)
	response := make([]byte, 6)
	response[0] = data[0] // 地址高字节
	response[1] = data[1] // 地址低字节
	response[2] = data[2] // 参数值字节0
	response[3] = data[3] // 参数值字节1
	response[4] = data[4] // 参数值字节2
	response[5] = data[5] // 参数值字节3

	fmt.Printf("✅ 网关参数写入成功\n")
	return response, nil
}

// HandleFunction0x54 处理读子设备参数
// 协议规范：请求3字节（地址2字节），响应7字节（地址2字节+参数值4字节）
func (gs *GatewaySimulator) HandleFunction0x54(unitID uint8, data []byte) ([]byte, error) {
	// 验证数据长度：地址(2字节)
	if len(data) < 2 {
		return nil, fmt.Errorf("invalid data length for function 0x54: expected 2, got %d", len(data))
	}

	// 验证Unit ID范围（子设备：1-64）
	if unitID < 1 || unitID > 64 {
		return nil, fmt.Errorf("invalid unit ID for sub-device: %d (expected 1-64)", unitID)
	}

	addr := uint16(data[0])<<8 | uint16(data[1])

	// 验证参数地址范围（子设备参数：0x0001-0x000A）
	if addr < 0x0001 || addr > 0x000A {
		return nil, fmt.Errorf("invalid parameter address for sub-device: 0x%04X (expected 0x0001-0x000A)", addr)
	}

	fmt.Printf("📖 功能码0x54 - Unit ID: %d, 地址: 0x%04X\n", unitID, addr)

	gs.mu.RLock()
	defer gs.mu.RUnlock()

	if params, exists := gs.subDevParams[int(unitID)]; exists {
		if param, paramExists := params[int(addr)]; paramExists && len(param) >= 4 {
			// 返回：地址(2字节) + 参数值(4字节)
			response := make([]byte, 6)
			response[0] = data[0]           // 地址高字节
			response[1] = data[1]           // 地址低字节
			copy(response[2:6], param[0:4]) // 参数值4字节

			paramValue := BytesToUint32(param[0:4])
			fmt.Printf("✅ 读取子设备参数成功: 0x%08X (%d)\n", paramValue, paramValue)
			return response, nil
		}
	}

	// 参数不存在，生成默认值
	defaultValue := gs.getDefaultSubDeviceParam(addr)
	defaultBytes := Uint32ToBytes(defaultValue)

	// 存储默认值
	if gs.subDevParams[int(unitID)] == nil {
		gs.subDevParams[int(unitID)] = make(map[int][]byte)
	}
	gs.subDevParams[int(unitID)][int(addr)] = make([]byte, 4)
	copy(gs.subDevParams[int(unitID)][int(addr)], defaultBytes)

	response := make([]byte, 6)
	response[0] = data[0]             // 地址高字节
	response[1] = data[1]             // 地址低字节
	copy(response[2:6], defaultBytes) // 默认参数值

	fmt.Printf("✅ 返回默认子设备参数: 0x%08X (%d)\n", defaultValue, defaultValue)
	return response, nil
}

// HandleFunction0x55 处理读网关参数
// 协议规范：请求3字节（地址2字节），响应7字节（地址2字节+参数值4字节）
func (gs *GatewaySimulator) HandleFunction0x55(unitID uint8, data []byte) ([]byte, error) {
	// 验证数据长度：地址(2字节)
	if len(data) < 2 {
		return nil, fmt.Errorf("invalid data length for function 0x55: expected 2, got %d", len(data))
	}

	// 验证Unit ID范围（网关：65-247）
	if unitID < 1 || unitID > 247 {
		return nil, fmt.Errorf("invalid unit ID for gateway: %d (expected 65-247)", unitID)
	}

	addr := uint16(data[0])<<8 | uint16(data[1])

	// 验证参数地址范围（网关参数：0x0001-0x0004）
	if addr < 0x0001 || addr > 0x0004 {
		return nil, fmt.Errorf("invalid parameter address for gateway: 0x%04X (expected 0x0001-0x0004)", addr)
	}

	fmt.Printf("📖 功能码0x55 - Unit ID: %d, 地址: 0x%04X\n", unitID, addr)

	gs.mu.RLock()
	defer gs.mu.RUnlock()

	if param, exists := gs.gatewayParams[int(unitID)]; exists && len(param) >= 4 {
		// 返回：地址(2字节) + 参数值(4字节)
		response := make([]byte, 6)
		response[0] = data[0]           // 地址高字节
		response[1] = data[1]           // 地址低字节
		copy(response[2:6], param[0:4]) // 参数值4字节

		paramValue := BytesToUint32(param[0:4])
		fmt.Printf("✅ 读取网关参数成功: 0x%08X (%d)\n", paramValue, paramValue)
		return response, nil
	}

	// 参数不存在，生成默认值
	defaultValue := gs.getDefaultGatewayParam(addr)
	defaultBytes := Uint32ToBytes(defaultValue)

	// 存储默认值
	gs.gatewayParams[int(unitID)] = make([]byte, 4)
	copy(gs.gatewayParams[int(unitID)], defaultBytes)

	response := make([]byte, 6)
	response[0] = data[0]             // 地址高字节
	response[1] = data[1]             // 地址低字节
	copy(response[2:6], defaultBytes) // 默认参数值

	fmt.Printf("✅ 返回默认网关参数: 0x%08X (%d)\n", defaultValue, defaultValue)
	return response, nil
}

// CustomServerHandler 自定义服务器处理器
type CustomServerHandler struct {
	simulator *GatewaySimulator
}

// NewCustomServerHandler 创建自定义处理器
func NewCustomServerHandler() *CustomServerHandler {
	return &CustomServerHandler{
		simulator: NewGatewaySimulator(),
	}
}

// HandleRequest 处理Modbus请求
func (h *CustomServerHandler) HandleRequest(adu []byte) ([]byte, error) {
	if len(adu) < 8 { // MBAP header(6) + unit ID(1) + function code(1)
		return nil, fmt.Errorf("invalid ADU length")
	}

	// 解析MBAP头
	transactionID := uint16(adu[0])<<8 | uint16(adu[1])
	protocolID := uint16(adu[2])<<8 | uint16(adu[3])
	unitID := adu[6]
	functionCode := adu[7]
	data := adu[8:]

	if protocolID != 0 {
		return nil, fmt.Errorf("invalid protocol ID")
	}

	// 处理网关协议功能码
	var response []byte
	var err error

	switch functionCode {
	case 0x50: // 读数据记录
		response, err = h.simulator.HandleFunction0x50(unitID, data)
	case 0x51: // 读当前数据
		response, err = h.simulator.HandleFunction0x51(unitID, data)
	case 0x52: // 写子设备参数
		response, err = h.simulator.HandleFunction0x52(unitID, data)
	case 0x53: // 写网关参数
		response, err = h.simulator.HandleFunction0x53(unitID, data)
	case 0x54: // 读子设备参数
		response, err = h.simulator.HandleFunction0x54(unitID, data)
	case 0x55: // 读网关参数
		response, err = h.simulator.HandleFunction0x55(unitID, data)
	default:
		return nil, fmt.Errorf("unsupported function code: 0x%02X", functionCode)
	}

	if err != nil {
		// 返回异常响应
		exceptionCode := byte(0x01) // 非法功能码
		if functionCode >= 0x50 && functionCode <= 0x55 {
			exceptionCode = 0x02 // 非法数据地址
		}

		responseADU := make([]byte, 9)
		responseADU[0] = adu[0]              // 事务ID高字节
		responseADU[1] = adu[1]              // 事务ID低字节
		responseADU[2] = 0                   // 协议ID高字节
		responseADU[3] = 0                   // 协议ID低字节
		responseADU[4] = 0                   // 长度高字节
		responseADU[5] = 3                   // 长度低字节
		responseADU[6] = unitID              // 单元ID
		responseADU[7] = functionCode | 0x80 // 异常功能码
		responseADU[8] = exceptionCode       // 异常码

		return responseADU, nil
	}

	// 构建正常响应ADU
	responseLength := uint16(len(response) + 2) // +2 for unit ID and function code
	responseADU := make([]byte, 6+2+len(response))

	responseADU[0] = byte(transactionID >> 8)  // 事务ID高字节
	responseADU[1] = byte(transactionID)       // 事务ID低字节
	responseADU[2] = 0                         // 协议ID高字节
	responseADU[3] = 0                         // 协议ID低字节
	responseADU[4] = byte(responseLength >> 8) // 长度高字节
	responseADU[5] = byte(responseLength)      // 长度低字节
	responseADU[6] = unitID                    // 单元ID
	responseADU[7] = functionCode              // 功能码
	copy(responseADU[8:], response)            // 响应数据

	return responseADU, nil
}

// 工具函数

// Float32ToBytes 将float32转换为大端字节序
func Float32ToBytes(f float32) []byte {
	bits := math.Float32bits(f)
	bytes := make([]byte, 4)
	bytes[0] = byte(bits >> 24)
	bytes[1] = byte(bits >> 16)
	bytes[2] = byte(bits >> 8)
	bytes[3] = byte(bits)
	return bytes
}

// BytesToFloat32 将大端字节序转换为float32
func BytesToFloat32(bytes []byte) float32 {
	if len(bytes) < 4 {
		return 0
	}
	bits := uint32(bytes[0])<<24 | uint32(bytes[1])<<16 | uint32(bytes[2])<<8 | uint32(bytes[3])
	return math.Float32frombits(bits)
}

// Uint32ToBytes 将uint32转换为大端字节序
func Uint32ToBytes(u uint32) []byte {
	bytes := make([]byte, 4)
	bytes[0] = byte(u >> 24)
	bytes[1] = byte(u >> 16)
	bytes[2] = byte(u >> 8)
	bytes[3] = byte(u)
	return bytes
}

// BytesToUint32 将大端字节序转换为uint32
func BytesToUint32(bytes []byte) uint32 {
	if len(bytes) < 4 {
		return 0
	}
	return uint32(bytes[0])<<24 | uint32(bytes[1])<<16 | uint32(bytes[2])<<8 | uint32(bytes[3])
}

// Uint16ToBytes 将uint16转换为大端字节序
func Uint16ToBytes(u uint16) []byte {
	bytes := make([]byte, 2)
	bytes[0] = byte(u >> 8)
	bytes[1] = byte(u)
	return bytes
}

// BytesToUint16 将大端字节序转换为uint16
func BytesToUint16(bytes []byte) uint16 {
	if len(bytes) < 2 {
		return 0
	}
	return uint16(bytes[0])<<8 | uint16(bytes[1])
}

// GetPressureUnitName 获取压力单位名称
func GetPressureUnitName(unit uint8) string {
	switch unit {
	case 0:
		return "Pa"
	case 1:
		return "kPa"
	case 2:
		return "MPa"
	case 3:
		return "bar"
	case 4:
		return "psi"
	case 5:
		return "kPa" // 默认
	default:
		return "Unknown"
	}
}

// GetConnectionStatusName 获取连接状态名称
func GetConnectionStatusName(status uint8) string {
	switch status {
	case 0:
		return "断开"
	case 1:
		return "正常"
	case 2:
		return "异常"
	default:
		return "未知"
	}
}

// FormatTimestamp 格式化Unix时间戳
func FormatTimestamp(timestamp uint32) string {
	t := time.Unix(int64(timestamp), 0)
	return t.Format("2006-01-02 15:04:05")
}

// validateSubDeviceParam 验证子设备参数值的合法性
func (gs *GatewaySimulator) validateSubDeviceParam(addr uint16, value uint32) error {
	switch addr {
	case 0x0001: // 压力单位 (0x01-0x0A)
		if value < 0x01 || value > 0x0A {
			return fmt.Errorf("pressure unit out of range: 0x%08X (expected 0x01-0x0A)", value)
		}
	case 0x0002: // 显示小数位 (0-3)
		if value > 3 {
			return fmt.Errorf("decimal places out of range: %d (expected 0-3)", value)
		}
	case 0x0003: // 压力上限 (0-1000000)
		if value > 1000000 {
			return fmt.Errorf("pressure upper limit out of range: %d (expected 0-1000000)", value)
		}
	case 0x0004: // 压力下限 (0-1000000)
		if value > 1000000 {
			return fmt.Errorf("pressure lower limit out of range: %d (expected 0-1000000)", value)
		}
	case 0x0005: // 采样间隔 (1-3600秒)
		if value < 1 || value > 3600 {
			return fmt.Errorf("sampling interval out of range: %d (expected 1-3600)", value)
		}
	default:
		// 其他地址暂时允许任意值
		break
	}
	return nil
}

// validateGatewayParam 验证网关参数值的合法性
func (gs *GatewaySimulator) validateGatewayParam(addr uint16, value uint32) error {
	switch addr {
	case 0x0001: // 网关地址 (65-247)
		if value < 65 || value > 247 {
			return fmt.Errorf("gateway address out of range: %d (expected 65-247)", value)
		}
	case 0x0002: // RS485波特率 (9600-230400)
		validBaudRates := []uint32{9600, 19200, 38400, 57600, 115200, 230400}
		valid := false
		for _, rate := range validBaudRates {
			if value == rate {
				valid = true
				break
			}
		}
		if !valid {
			return fmt.Errorf("invalid baud rate: %d (expected 9600/19200/38400/57600/115200/230400)", value)
		}
	case 0x0003: // 网络端口 (1024-65535)
		if value < 1024 || value > 65535 {
			return fmt.Errorf("network port out of range: %d (expected 1024-65535)", value)
		}
	case 0x0004: // 心跳间隔 (10-300秒)
		if value < 10 || value > 300 {
			return fmt.Errorf("heartbeat interval out of range: %d (expected 10-300)", value)
		}
	default:
		return fmt.Errorf("unknown gateway parameter address: 0x%04X", addr)
	}
	return nil
}

// getDefaultSubDeviceParam 获取子设备参数的默认值
func (gs *GatewaySimulator) getDefaultSubDeviceParam(addr uint16) uint32 {
	switch addr {
	case 0x0001: // 压力单位，默认kPa
		return 0x05
	case 0x0002: // 显示小数位，默认2位
		return 2
	case 0x0003: // 压力上限，默认1000kPa
		return 1000
	case 0x0004: // 压力下限，默认0kPa
		return 0
	case 0x0005: // 采样间隔，默认60秒
		return 60
	case 0x0006: // 报警使能，默认关闭
		return 0
	case 0x0007: // 高压报警值，默认800kPa
		return 800
	case 0x0008: // 低压报警值，默认100kPa
		return 100
	case 0x0009: // 设备地址，默认1
		return 1
	case 0x000A: // 通信超时，默认5秒
		return 5
	default:
		return 0
	}
}

// getDefaultGatewayParam 获取网关参数的默认值
func (gs *GatewaySimulator) getDefaultGatewayParam(addr uint16) uint32 {
	switch addr {
	case 0x0001: // 网关地址，默认65
		return 65
	case 0x0002: // RS485波特率，默认115200
		return 115200
	case 0x0003: // 网络端口，默认5020
		return 5020
	case 0x0004: // 心跳间隔，默认30秒
		return 30
	default:
		return 0
	}
}

// NewModbusServer 创建Modbus服务器
func NewModbusServer(address string) (*ModbusServer, error) {
	listener, err := net.Listen("tcp", address)
	if err != nil {
		return nil, err
	}

	ctx, cancel := context.WithCancel(context.Background())

	server := &ModbusServer{
		listener: listener,
		handler:  NewCustomServerHandler(),
		ctx:      ctx,
		cancel:   cancel,
	}

	return server, nil
}

// Start 启动服务器
func (s *ModbusServer) Start() error {
	log.Printf("网关协议模拟器启动，监听地址: %s", s.listener.Addr().String())
	log.Println("支持的功能码:")
	log.Println("  0x50 - 读数据记录")
	log.Println("  0x51 - 读当前数据")
	log.Println("  0x52 - 写子设备参数")
	log.Println("  0x53 - 写网关参数")
	log.Println("  0x54 - 读子设备参数")
	log.Println("  0x55 - 读网关参数")
	log.Println("变送器Unit ID范围: 1-64")
	log.Println("网关Unit ID范围: 65-247")

	for {
		select {
		case <-s.ctx.Done():
			return nil
		default:
			conn, err := s.listener.Accept()
			if err != nil {
				if s.ctx.Err() != nil {
					return nil
				}
				log.Printf("接受连接失败: %v", err)
				continue
			}

			s.wg.Add(1)
			go s.handleConnection(conn)
		}
	}
}

// handleConnection 处理单个连接
func (s *ModbusServer) handleConnection(conn net.Conn) {
	defer s.wg.Done()
	defer conn.Close()

	log.Printf("新客户端连接: %s", conn.RemoteAddr().String())

	for {
		select {
		case <-s.ctx.Done():
			return
		default:
			// 设置读取超时
			conn.SetReadDeadline(time.Now().Add(30 * time.Second))

			// 读取MBAP头
			header := make([]byte, 6)
			_, err := conn.Read(header)
			if err != nil {
				if netErr, ok := err.(net.Error); ok && netErr.Timeout() {
					continue
				}
				log.Printf("读取MBAP头失败: %v", err)
				return
			}

			// 解析数据长度
			length := uint16(header[4])<<8 | uint16(header[5])
			if length < 2 || length > 253 {
				log.Printf("无效的数据长度: %d", length)
				return
			}

			// 读取剩余数据
			data := make([]byte, length)
			_, err = conn.Read(data)
			if err != nil {
				log.Printf("读取数据失败: %v", err)
				return
			}

			// 组装完整的ADU
			adu := append(header, data...)

			// 处理请求
			response, err := s.handler.HandleRequest(adu)
			if err != nil {
				log.Printf("处理请求失败: %v", err)
				continue
			}

			// 发送响应
			_, err = conn.Write(response)
			if err != nil {
				log.Printf("发送响应失败: %v", err)
				return
			}

			// 记录处理的功能码
			if len(adu) >= 8 {
				unitID := adu[6]
				functionCode := adu[7]
				log.Printf("处理请求 - Unit ID: %d, 功能码: 0x%02X", unitID, functionCode)
			}
		}
	}
}

// Stop 停止服务器
func (s *ModbusServer) Stop() error {
	log.Println("正在停止网关协议模拟器...")
	s.cancel()
	s.listener.Close()
	s.wg.Wait()
	log.Println("网关协议模拟器已停止")
	return nil
}

func main() {
	// 创建服务器
	server, err := NewModbusServer(":5020")
	if err != nil {
		log.Fatalf("创建服务器失败: %v", err)
	}

	// 启动服务器
	go func() {
		if err := server.Start(); err != nil {
			log.Fatalf("启动服务器失败: %v", err)
		}
	}()

	// 等待中断信号
	log.Println("按 Ctrl+C 停止模拟器")
	select {}
}
